// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/strings/stringprintf.h"

#include <errno.h>
#include <stddef.h>

#include <vector>

#include "base/macros.h"
#include "base/scoped_clear_errno.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "build/build_config.h"

namespace base {

namespace {

    // Overloaded wrappers around vsnprintf and vswprintf. The buf_size parameter
    // is the size of the buffer. These return the number of characters in the
    // formatted string excluding the NUL terminator. If the buffer is not
    // large enough to accommodate the formatted string without truncation, they
    // return the number of characters that would be in the fully-formatted string
    // (vsnprintf, and vswprintf on Windows), or -1 (vswprintf on POSIX platforms).
    inline int vsnprintfT(char* buffer,
        size_t buf_size,
        const char* format,
        va_list argptr)
    {
        return base::vsnprintf(buffer, buf_size, format, argptr);
    }

#if defined(OS_WIN)
    inline int vsnprintfT(wchar_t* buffer,
        size_t buf_size,
        const wchar_t* format,
        va_list argptr)
    {
        return base::vswprintf(buffer, buf_size, format, argptr);
    }
#endif

    // Templatized backend for StringPrintF/StringAppendF. This does not finalize
    // the va_list, the caller is expected to do that.
    template <class StringType>
    static void StringAppendVT(StringType* dst,
        const typename StringType::value_type* format,
        va_list ap)
    {
        // First try with a small fixed size buffer.
        // This buffer size should be kept in sync with StringUtilTest.GrowBoundary
        // and StringUtilTest.StringPrintfBounds.
        typename StringType::value_type stack_buf[1024];

        va_list ap_copy;
        va_copy(ap_copy, ap);

#if !defined(OS_WIN)
        ScopedClearErrno clear_errno;
#endif
        int result = vsnprintfT(stack_buf, arraysize(stack_buf), format, ap_copy);
        va_end(ap_copy);

        if (result >= 0 && result < static_cast<int>(arraysize(stack_buf))) {
            // It fit.
            dst->append(stack_buf, result);
            return;
        }

        // Repeatedly increase buffer size until it fits.
        int mem_length = arraysize(stack_buf);
        while (true) {
            if (result < 0) {
#if defined(OS_WIN)
                // On Windows, vsnprintfT always returns the number of characters in a
                // fully-formatted string, so if we reach this point, something else is
                // wrong and no amount of buffer-doubling is going to fix it.
                return;
#else
                if (errno != 0 && errno != EOVERFLOW)
                    return;
                // Try doubling the buffer size.
                mem_length *= 2;
#endif
            } else {
                // We need exactly "result + 1" characters.
                mem_length = result + 1;
            }

            if (mem_length > 32 * 1024 * 1024) {
                // That should be plenty, don't try anything larger.  This protects
                // against huge allocations when using vsnprintfT implementations that
                // return -1 for reasons other than overflow without setting errno.
                DLOG(WARNING) << "Unable to printf the requested string due to size.";
                return;
            }

            std::vector<typename StringType::value_type> mem_buf(mem_length);

            // NOTE: You can only use a va_list once.  Since we're in a while loop, we
            // need to make a new copy each time so we don't use up the original.
            va_copy(ap_copy, ap);
            result = vsnprintfT(&mem_buf[0], mem_length, format, ap_copy);
            va_end(ap_copy);

            if ((result >= 0) && (result < mem_length)) {
                // It fit.
                dst->append(&mem_buf[0], result);
                return;
            }
        }
    }

} // namespace

std::string StringPrintf(const char* format, ...)
{
    va_list ap;
    va_start(ap, format);
    std::string result;
    StringAppendV(&result, format, ap);
    va_end(ap);
    return result;
}

#if defined(OS_WIN)
std::wstring StringPrintf(const wchar_t* format, ...)
{
    va_list ap;
    va_start(ap, format);
    std::wstring result;
    StringAppendV(&result, format, ap);
    va_end(ap);
    return result;
}
#endif

std::string StringPrintV(const char* format, va_list ap)
{
    std::string result;
    StringAppendV(&result, format, ap);
    return result;
}

const std::string& SStringPrintf(std::string* dst, const char* format, ...)
{
    va_list ap;
    va_start(ap, format);
    dst->clear();
    StringAppendV(dst, format, ap);
    va_end(ap);
    return *dst;
}

#if defined(OS_WIN)
const std::wstring& SStringPrintf(std::wstring* dst,
    const wchar_t* format, ...)
{
    va_list ap;
    va_start(ap, format);
    dst->clear();
    StringAppendV(dst, format, ap);
    va_end(ap);
    return *dst;
}
#endif

void StringAppendF(std::string* dst, const char* format, ...)
{
    va_list ap;
    va_start(ap, format);
    StringAppendV(dst, format, ap);
    va_end(ap);
}

#if defined(OS_WIN)
void StringAppendF(std::wstring* dst, const wchar_t* format, ...)
{
    va_list ap;
    va_start(ap, format);
    StringAppendV(dst, format, ap);
    va_end(ap);
}
#endif

void StringAppendV(std::string* dst, const char* format, va_list ap)
{
    StringAppendVT(dst, format, ap);
}

#if defined(OS_WIN)
void StringAppendV(std::wstring* dst, const wchar_t* format, va_list ap)
{
    StringAppendVT(dst, format, ap);
}
#endif

} // namespace base
